package com.christina.engine.strategy.model;

import lombok.Builder;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.Map;

/**
 * 路由决策结果
 * 包含路由决策的详细信息
 * 
 * @author Christina
 */
@Data
@Builder
public class RoutingDecision {
    
    /**
     * 目标服务名称
     */
    private String targetService;
    
    /**
     * 服务方法名称
     */
    private String serviceMethod;
    
    /**
     * 决策置信度 (0.0 - 1.0)
     */
    private Double confidence;
    
    /**
     * 决策原因
     */
    private String reason;
    
    /**
     * 使用的策略名称
     */
    private String strategyName;
    
    /**
     * 决策时间
     */
    private LocalDateTime decisionTime;
    
    /**
     * 是否需要回退策略
     */
    private Boolean needsFallback;
    
    /**
     * 回退服务名称
     */
    private String fallbackService;
    
    /**
     * 预期执行时间（毫秒）
     */
    private Long expectedExecutionTime;
    
    /**
     * 路由参数
     */
    private Map<String, Object> routingParameters;
    
    /**
     * 决策元数据
     */
    private Map<String, Object> metadata;
    
    /**
     * 是否为有效决策
     */
    private Boolean valid;
    
    /**
     * 错误信息（如果决策失败）
     */
    private String errorMessage;
    
    /**
     * 决策权重
     */
    private Double weight;
    
    /**
     * 创建成功的路由决策
     * 
     * @param targetService 目标服务
     * @param confidence 置信度
     * @param strategyName 策略名称
     * @return 路由决策
     */
    public static RoutingDecision success(String targetService, Double confidence, String strategyName) {
        return RoutingDecision.builder()
                .targetService(targetService)
                .confidence(confidence)
                .strategyName(strategyName)
                .decisionTime(LocalDateTime.now())
                .valid(true)
                .needsFallback(false)
                .build();
    }
    
    /**
     * 创建失败的路由决策
     * 
     * @param errorMessage 错误信息
     * @param strategyName 策略名称
     * @return 路由决策
     */
    public static RoutingDecision failure(String errorMessage, String strategyName) {
        return RoutingDecision.builder()
                .errorMessage(errorMessage)
                .strategyName(strategyName)
                .decisionTime(LocalDateTime.now())
                .valid(false)
                .confidence(0.0)
                .build();
    }
    
    /**
     * 创建需要回退的路由决策
     * 
     * @param targetService 目标服务
     * @param fallbackService 回退服务
     * @param confidence 置信度
     * @param strategyName 策略名称
     * @return 路由决策
     */
    public static RoutingDecision withFallback(String targetService, String fallbackService, 
                                             Double confidence, String strategyName) {
        return RoutingDecision.builder()
                .targetService(targetService)
                .fallbackService(fallbackService)
                .confidence(confidence)
                .strategyName(strategyName)
                .decisionTime(LocalDateTime.now())
                .valid(true)
                .needsFallback(true)
                .build();
    }
    
    /**
     * 检查决策是否成功
     * 
     * @return 是否成功
     */
    public boolean isSuccessful() {
        return Boolean.TRUE.equals(valid) && targetService != null && !targetService.trim().isEmpty();
    }
    
    /**
     * 检查是否有高置信度
     * 
     * @return 是否高置信度
     */
    public boolean isHighConfidence() {
        return confidence != null && confidence >= 0.8;
    }
    
    /**
     * 检查是否有中等置信度
     * 
     * @return 是否中等置信度
     */
    public boolean isMediumConfidence() {
        return confidence != null && confidence >= 0.5 && confidence < 0.8;
    }
    
    /**
     * 检查是否为低置信度
     * 
     * @return 是否低置信度
     */
    public boolean isLowConfidence() {
        return confidence != null && confidence < 0.5;
    }
}